/**

 函数式接口		参数类型		返回类型		用途
Consumer<T>    	T			Void		对类型为T的对象应用操作，包含方法：void accept(T t）
Supplier<T> 	无			T			返回类型为T的对象，包含方法:T get()
Function<T,R>	T			R			对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t）
Predicate<T>	T			boolean		确定类型为T的对象是否满足某约束，并返回BOOLEAN值。包含方法：Boolean test(T t）	
 
 Function 接口         
 在JAVA8以后的接口可以有接口方法的默认实现了，function源代码如下
 
 //将参数赋予给相应方法，传入T，返回R
 R apply（T t);
 
 //先执行参数，再执行调用者 两个Function，先执行后面的，再执行前面的
 fun1.compose(fun2)    先执行fun2  再执行fun1
 
 //先执行调用者，再执行参数，和compose相反。先执行第一个fun1，再接着执行后面的fun2
 fun1.andthen（fun2）   先执行fun1  再执行fun2
 
 //返回当前正在执行的方法
 identity
 */
/*
package com.leo.第九章_集合;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Collectors;

public class U9_L6_JDK8_4大核心接口_Function接口 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Function<Integer,String> inttostring=n->String.valueOf(n);
			//3种实例化方式
			function_3();
//			//转换数据类型
			changetype();
			//andthen
			andthen();
			//Compose
			compose();
			//条件处理
			function();
			//
			optional_null();
			stream();
			bifunction();
			result();
		}
	
	//3种Function接口的实例化方式
	private static void function_3() {
		//1.Lambda表达式创建Function实例
		Function<Integer,String> intToString1=(Integer num)->String.valueOf(num);
		//2.方法引用创建Function实例
		Function<Integer,String>intToString2=String::valueOf;
		//3.匿名内部类创建Function实例
		Function<Integer,String>intToString3=new Function<Integer,String>(){
			public String apply(Integer num) {
				return String.valueOf(num);
		}};
		System.out.println("Lambda实例化： "+intToString1+
				"\n方法引用： "+intToString2+
				"\n匿名内部类： "+intToString3);
	}
	
	//转换数据类型
	private static void changetype() {
		Function<String,Integer> StringToInt=Integer::parseInt;
		int result=StringToInt.apply("123");
		System.out.println("result: "+result);
	}
	
	//andThen方法(串联）
	private static void andthen() {
		Function<Integer,String> inttoString=num->String.valueOf(num);
		Function<String,String>quote=str->"\""+str +"\"";
		
		Function<Integer,String> inToQuotedString=inttoString.andThen(quote);
		String result=inToQuotedString.apply(42);
	}
	
	//compose方法（逆序）
	private static void compose() {
		//fun1 和 fun2   转换  添加 前缀 
		Function<Integer,String> inttostring=num->String.valueOf(num);
		Function<String,String> addprefix=str->"Value: "+str;
		//compose  执行fun2 再执行fun1
		Function<Integer,String>prefixedIntToString=addprefix.compose(inttostring);
//		//apply  将参数传入 fun2 和 fun1
		String result=prefixedIntToString.apply(42);
		System.out.println("result - "+result);
	}
	
	//处理集合数据
	private static void stream() {
		List <String> names=Arrays.asList("Alice","Bob","Charlie");
		Function<String,String> toUpperCase=String::toUpperCase;
		
		List<String> upperCaseNames =names.stream()
					.map(toUpperCase)
					.collect(Collectors.toList());
		System.out.println("处理集合数据: "+upperCaseNames);
		
	}
	
	//条件处理
	private static void function() {
		Function<Integer,String> classifyAge=age->{
			if(age<18) {
				return "Young";
			}else if(age<65) {
				return "Adult";
			}else {
				return "Senior";
			}
		};
		
		String ageCategory= classifyAge.apply(30);
		System.out.println("传入参数，输出value（写入规则）： "+ageCategory);
	}
	
	//函数默认值
	private static void optional_null() {
		Function<String,String> addprefix=str->"Value: "+str;
		
		String result=Optional.ofNullable("42")
				.map(addprefix)
				.orElse("Value:N/A");
		System.out.println("result: "+result);
	}
	//将多个参数转成1个参数
	private static void bifunction() {
		BiFunction<Integer,Integer,Integer> sum=(a,b)->a+b;
		Function<Integer,Function<Integer,Integer>> partiallyAppliedSum
				  = a->b->sum.apply(a, b); 
		int result=partiallyAppliedSum.apply(3).apply(5);
		System.out.println("result: "+result);
	}
	//方法链式调用
	private static void result() {
		Function<String,String> removeWhitespace=str->str.replaceAll("\\s+", "");// \\s+  至少一个空格（regex）
		Function<String,String> toLowerCase=String::toLowerCase;
		Function<String,String> truncate =str->str.substring(0,Math.min(str.length(), 10));
		
		Function<String,String> dataProcessingPipeline=removeWhitespace.andThen(toLowerCase).andThen(truncate);
		
		String result=dataProcessingPipeline.apply(" hello, Word!   ");
		System.out.println(result);
	}

}
*/
 

